home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Scheduling / Cassandra / Source / convert / Event.m < prev    next >
Encoding:
Text File  |  1991-10-03  |  14.6 KB  |  810 lines
  1. //
  2. // Event.m
  3. // Copyright (c) 1988, 1989, 1990 by Jiro Nakamura 
  4. // All rights reserved
  5. //
  6. // Implementation definition of class Event. Event handles 
  7. // the database management of Cassandra.
  8. //
  9. // RCS Information
  10. // Revision Number->    $Revision: 2.10 $
  11. // Last Revised->    $Date: 91/01/27 15:35:26 $
  12. //
  13. static char rcsid[] = "$Id: Event.m,v 2.10 91/01/27 15:35:26 jiro Exp Locker: jiro $";
  14.  
  15. #import "Event.h"
  16. #import <objc/objc.h>
  17. #import <strings.h>
  18. #import <appkit/Panel.h>       /* for NXRunAlertPanel */
  19. #import "cass.h"    
  20. #import "calendar.h"
  21. #import "Global.h"
  22. #import "misc.h"
  23. #import <sys/types.h>
  24. #import <sys/stat.h>
  25.     
  26. // Defining DEBUG for Event can sometimes get very screen messy
  27. // since Cassandra uses it so often
  28. // #undef DEBUG
  29.  
  30. int fgeti( int *i ,     FILE *fp)        
  31. {
  32.     char buffer[10];
  33.     if( fgets(buffer, 10, fp) == NULL)
  34.         return -1;
  35.     *i = atoi(buffer);
  36.     return 0;
  37. }
  38.         
  39.  
  40. @implementation Event
  41.  
  42. + newAt:(const char*) eFile
  43. {
  44.     self = [super new];
  45.     strcpy(eventFile,eFile);
  46.  
  47.     priority = 50;
  48.     destroy = snoozeNo = snoozeInt =0;
  49.     anniversary =  annvSpecial = 0;
  50.     present = next = previous = 0;
  51.     showMessage = TRUE;
  52.     playAlarm = TRUE;
  53.     
  54.     strcpy(alarmSound, ALARMSOUND);
  55.     strcpy(msg,"empty");
  56.     return self;
  57. }
  58.  
  59. + new
  60. {
  61.     fprintf(stderr,"This should never be called!");
  62.     self = [super new];
  63.     return self;
  64. }
  65.  
  66. - free
  67. {
  68. #ifdef DEBUG
  69.     fprintf(stderr,"Event.m:Free ->Closing event!\n");
  70. #endif
  71.     [super free];
  72.     return nil;
  73. }
  74.  
  75. //
  76. //
  77. // Messages that affect how the file is stored on disk
  78. //
  79. //
  80.  
  81. - default: sender
  82. {
  83.     present =  0;
  84.     previous = next = -1;
  85.     destroy =  1;
  86.     anniversary = annvSpecial = snoozeInt = snoozeNo = priority = 0;
  87.     ts.tm_sec =  ts.tm_min =  ts.tm_hour = 0;
  88.     ts.tm_mday = ts.tm_mon =  ts.tm_year = 0;
  89.     ts.tm_wday =  ts.tm_yday =  ts.tm_isdst = 0;
  90.     
  91.     strcpy(msg, "");
  92.     strcpy(alarmSound,[global alarmSound]);
  93.     return self;
  94. }
  95.  
  96.  
  97. - readEvent: (EFileLink) here        /* read itself from the event file */
  98. {
  99.     FILE * source;
  100.     static char errormsg[128], buffer[10];
  101.     char *tp;    // temporary pointer
  102.     struct stat statBuf;
  103.     
  104.     #ifdef DEBUG
  105.         fprintf(stderr,    "------------------------\n"
  106.                     "[Event readEvent: %d]\n",here);
  107.     #endif
  108.  
  109.     if( here < 0)
  110.         {
  111.         NXRunAlertPanel("File Seek Error", 
  112.                 "Cannot seek to a negative number.",
  113.                  "OK",NULL,NULL);
  114.         strcpy(msg, "Illegal event/link value....");
  115.         return nil;
  116.         }
  117.         
  118.     /* Let's first check to make sure we aren't reading an empty file */
  119.     stat( eventFile, &statBuf);
  120.     if( statBuf.st_size < 100)    // It can not be this short
  121.         {
  122.         strcpy(msg, CASSANDRAVERSION);
  123.         next = previous = 0;
  124.         present = here;                    
  125.         [self writeEvent: here];
  126.         fprintf(stderr, "%s: Event list not initialized. "
  127.             "Initializing....\n",
  128.             PROGNAME);
  129.         return nil;
  130.         }
  131.  
  132.     sprintf(errormsg, "Error occured while trying to read event file %s", 
  133.         eventFile);
  134.     source = fileOpen(eventFile, "r+",errormsg);
  135.     
  136.     sprintf(errormsg,     "An fatal error occured when we were trying "
  137.                 "to seek to event number %d for reading event "
  138.                 "file %s.\n This program has crashed.", 
  139.                 here, eventFile);
  140.     if( fileSeek(source, here, errormsg) == NULL)
  141.         {
  142.         next = previous = -1;
  143.         present = here;
  144.         return nil;
  145.         }
  146.     
  147.     present = fgetnum(source);
  148.     if( present != here)
  149.         {
  150.         fprintf(stderr, 
  151.             "%s: Uh oh.... File header gives %d instead of %d.\n"
  152.             "%s: We've most probably run out off the end of %s.\n"
  153.             "%s: Not to worry. :-) I'll extend it.\n",
  154.             PROGNAME ,present, here,
  155.             PROGNAME, [global eventFile],
  156.             PROGNAME);
  157.         next = previous = -1;
  158.         present = here;
  159.         fclose(source);
  160.         return nil;
  161.         }
  162.     else
  163.         {
  164.         previous = fgetnum(source);
  165.         next = fgetnum(source);
  166.         }
  167.  
  168.     fgets( buffer, 10, source);
  169.     fgets( buffer, 10, source);
  170.     
  171.     fgeti( &priority, source);
  172.     fgeti( &destroy, source);
  173.     fgeti( &anniversary, source);
  174.     fgeti( &snoozeNo, source);
  175.     fgeti( &snoozeInt, source);
  176.     
  177.     fgets( buffer, 10, source);
  178.     fgets( buffer, 10, source);
  179.     
  180.     fgeti( &ts.tm_sec, source);
  181.     fgeti( &ts.tm_min, source);
  182.     fgeti( &ts.tm_hour, source);
  183.     fgeti( &ts.tm_mday, source);
  184.     fgeti( &ts.tm_mon, source);
  185.     fgeti( &ts.tm_year, source);
  186.     fgeti( &ts.tm_wday, source);
  187.     fgeti( &ts.tm_yday, source);
  188.     fgeti( &ts.tm_isdst, source);
  189.     
  190.     fgets( alarmSound, 100, source);    // We gotta strip the final
  191.     tp = rindex( alarmSound, '\n');        // newline and replace it with
  192.     if( tp != NULL)                // a NULL character.
  193.         *tp = '\0';
  194.     
  195.     fgets( buffer, 10, source);
  196.     fgets( buffer, 10, source);
  197.     fgets( buffer, 10, source);
  198.     fgets( buffer, 10, source);
  199.  
  200.     fgets(msg,MESSAGE_SIZE,source);
  201.                 
  202.     ts.tm_wday = wday(ts.tm_mday, ts.tm_mon+1, 1900+ts.tm_year);
  203.     ts.tm_yday = yday(ts.tm_mday, ts.tm_mon+1, ts.tm_year+1900);
  204.     
  205.     playAlarm = TRUE;
  206.     deleteSound = FALSE;
  207.     annvSpecial = 0;
  208.     
  209.     if( alarmSound[0] == '-')
  210.         {
  211.         char buf[255];
  212.         
  213.         strcpy(buf, alarmSound);
  214.         strcpy(alarmSound, buf+1);
  215.         playAlarm = FALSE;
  216.         }
  217.     else
  218.         {
  219.         if( alarmSound[0] == '?')
  220.             {
  221.             char buf[255];
  222.             strcpy(buf, alarmSound);
  223.             strcpy(alarmSound, buf+1);
  224.             deleteSound = TRUE;
  225.             }
  226.         }
  227.     
  228.     if( msg[0] == ';')
  229.         {
  230.         char buf[MESSAGE_SIZE];
  231.         
  232.         strcpy(buf, msg);
  233.         strcpy(msg, buf+1);
  234.         showMessage = FALSE;
  235.         }
  236.     else
  237.         showMessage = TRUE;
  238.             
  239.     fclose(source);
  240.     return self;
  241. }
  242.                 
  243. - firstEvent
  244. {
  245.     #ifdef DEBUG
  246.         fprintf(stderr,"Reading in the first event.\n");
  247.     #endif
  248.  
  249.     [self readEvent : 0];
  250.     if( [self next] == 0)
  251.         return self;
  252.     [self readEvent : [self next]];
  253.     return self;
  254. }    
  255.     
  256. - writeEvent: (EFileLink) here    
  257. /* write itself into the event file using present as its index */
  258. {
  259.     FILE *source;
  260.     char errormsg[256], bufAlarm[256], bufMessage[256];
  261.         
  262.     if( here < 0)
  263.         {
  264.         NXRunAlertPanel( "Write Error", 
  265.                 "We can't write to a negative event number.",
  266.                 "OK",NULL,NULL);
  267.         return nil;
  268.         }
  269.         
  270.     #ifdef DEBUG
  271.         fprintf(stderr,    "------------------------\n"
  272.                 "[Event writeEvent: %d]: Opening event with "
  273.                 "<%s>!\n",here, eventFile);
  274.     #endif
  275.  
  276.     sprintf(errormsg, "Fatal error when trying to write to event file %s", 
  277.         eventFile);
  278.     source = fileOpen(eventFile, "r+",errormsg);
  279.     
  280.     sprintf(errormsg, "%s: An fatal error occured when we were trying to "
  281.             "seek to event number %d for writing in event file %s.\n"
  282.             " This program has crashed.", PROGNAME, here, eventFile);
  283.     fileSeek(source, here, errormsg);
  284.     
  285.     present = here;
  286.     
  287.     if( ts.tm_year > 1900)
  288.         ts.tm_year -= 1900;
  289.  
  290.     if( playAlarm == FALSE)
  291.         {        
  292.         strcpy(bufAlarm, "-");
  293.         strcat(bufAlarm,alarmSound);
  294.         }
  295.     else
  296.         {
  297.         if( deleteSound == TRUE )
  298.             {
  299.             strcpy(bufAlarm, "?");
  300.             strcat(bufAlarm,alarmSound);
  301.             }
  302.         else
  303.             strcpy(bufAlarm, alarmSound);
  304.         }
  305.  
  306.     if( showMessage == FALSE)
  307.         {        
  308.         strcpy(bufMessage, ";");
  309.         strcat(bufMessage, msg);
  310.         }
  311.     else
  312.         strcpy(bufMessage, msg);
  313.  
  314.  
  315.     if(fprintf( source,         "%d\n%d\n%d\n"
  316.                     "\n\n"
  317.                     "%d\n%d\n%d\n"
  318.                     "%d\n%d\n"
  319.                     "\n\n"
  320.                     "%d\n%d\n%d\n"
  321.                     "%d\n%d\n%d\n"
  322.                     "%d\n%d\n%d\n"
  323.                     "%s\n\n"
  324.                     "\n\n\n"
  325.                     "%s\n",
  326.                     present, previous, next,
  327.                     priority,destroy, anniversary,
  328.                     snoozeNo, snoozeInt,
  329.                     ts.tm_sec, ts.tm_min, ts.tm_hour,
  330.                     ts.tm_mday, ts.tm_mon, ts.tm_year,
  331.                     ts.tm_wday, ts.tm_yday, ts.tm_isdst,
  332.                     bufAlarm, bufMessage) == -1)
  333.         {
  334.         fprintf(stderr, "%s: Event.m:   Error occured writing file.",
  335.              PROGNAME);
  336.         strcpy(msg, "Error occured in writing out Elink number.\n\n");
  337.         fclose(source);
  338.         return nil;
  339.         }
  340.     
  341.         #ifdef DEBUG
  342.             fprintf(stderr, "%s: Wrote out Efilelink.\n  Here = %d, "
  343.                 "Previous = %d, Next=%d\n", PROGNAME,
  344.                 here, previous, next);
  345.             fprintf(stderr, "%s: Date:   time = %d:%d, day= %d, "
  346.                 "month = %d, year = %d.\n\n",PROGNAME,
  347.                 ts.tm_hour, ts.tm_min, ts.tm_mday, ts.tm_mon, 
  348.                 ts.tm_year);
  349.             fprintf(stderr,"%s: AlarmSound =%s\n", PROGNAME, bufAlarm);
  350.         #endif
  351.         
  352.     fclose(source);
  353.     return self;
  354. }
  355.  
  356. - (EFileLink) insertEvent
  357. {
  358.     return [self insertEventFrom : 1];
  359. }
  360.  
  361.  
  362.  
  363. /* insert itself into the file with current day as index */
  364. /* and starting from <here> in searching for a open deleted space */
  365. - (EFileLink) insertEventFrom : (EFileLink) here
  366. {
  367.     id event, step;
  368.     int loop;
  369.     
  370.  
  371.     // First things first, we must check the format of our time structure  
  372.     // since we have given other functions full freedom to scew it up
  373.  
  374.     fixTmStructure( &ts);
  375.             
  376.     event = [Event newAt:eventFile];
  377.     step = [Event newAt:eventFile];
  378.     [event readEvent:0];
  379.     for( [event readEvent: [event next]]; 
  380.           [event present] != 0 && timeCompare([event time], &ts) < 1;
  381.           [event readEvent:[event next]])
  382.               {
  383.               #ifdef DEBUG
  384.             fprintf(stderr, "From %d looping onto %d\n",[event present],[event next]);
  385.         #endif
  386.         }
  387.     #ifdef DEBUG    
  388.         fprintf(stderr, "inserting between %d <- event -> %d.\n",[event previous], [event present]);
  389.     #endif
  390.     
  391.     previous = [event previous];
  392.     next = [event present];
  393.     
  394.     [step setNext: 0];
  395.     for( loop = here; !([step next] == -1 && [step previous] == -1); [step readEvent: loop++])
  396.         {
  397.         #ifdef DEBUG
  398.             fprintf(stderr, "reading at %d.\n",loop);
  399.         #endif
  400.         }
  401.         
  402.     present = [step present];
  403.     
  404.     [self writeEvent: present];
  405.     
  406.     [step readEvent: previous];
  407.     [step setNext : present];
  408.     [step writeEvent:previous];
  409.     
  410.     [step readEvent: next];
  411.     [step setPrevious : present];
  412.     [step writeEvent:next];
  413.     
  414.     [step free];
  415.     [event free];
  416.     #ifdef DEBUG
  417.         fprintf(stderr,"successfully inserted %d <- %d -> %d\n\n",[self previous],[self present], [self next]);
  418.     #endif
  419.  
  420.     
  421.     return( [self present] );
  422. }
  423.  
  424. /* delete itself from the file with present as index */
  425. - deleteEvent  : (EFileLink) here 
  426. {
  427.     id previousEvent, nextEvent;
  428.     
  429.     #ifdef DEBUG
  430.         fprintf(stderr, "Deleting <%d>\n\n",here);
  431.     #endif
  432.     
  433.     if( here <= 0)
  434.         {
  435.         NXRunAlertPanel(NULL,"You cannot delete link 0 or below. OK?",
  436.                  "Shucks...",NULL,NULL);
  437.         fprintf(stderr,"Can't delete the header.  Here = %d.\n\n",
  438.              here);
  439.         return nil;
  440.         }
  441.     
  442.     previousEvent= [Event newAt: eventFile];
  443.     nextEvent = [Event newAt:eventFile];
  444.     
  445.     [previousEvent readEvent  :here];
  446.     if( ( [previousEvent previous] == -1  )   || 
  447.         ( [previousEvent next]  == -1  )        )
  448.         {
  449.         /*   link was already deleted, so we can't delete it..... */
  450.         strcpy(msg, "Can't delete link because it's already been "
  451.             "deleted!?!\n\n");
  452.         return nil;
  453.         }
  454.     
  455.     /* Set the previous_link of the next link */
  456.     /* to the one of the previous one */                    
  457.     [nextEvent readEvent :[previousEvent next]];    
  458.     [nextEvent setPrevious  : [previousEvent previous]];            
  459.     [nextEvent writeEvent  :[previousEvent next]];    
  460.     
  461.     /* do the same confusing spiel for previous */
  462.     [nextEvent readEvent  :[previousEvent previous] ];    
  463.     [nextEvent setNext  : [previousEvent next]];
  464.     [nextEvent writeEvent  :[previousEvent previous] ];
  465.     
  466.     /* cancel out the header to finally kill it */
  467.     /* and write it out */
  468.     [previousEvent setNext  : -1];    
  469.     [previousEvent setPrevious  :-1];    
  470.     [previousEvent writeEvent  :here];    
  471.     
  472.     #ifdef DEBUG
  473.         fprintf(stderr, "Record %d successfully deleted.\n\n", 
  474.             here);
  475.     #endif
  476.     
  477.     [previousEvent free];
  478.     [nextEvent free];
  479.     return self;
  480. }
  481.  
  482. /* delete if it is not an anniversary event, update otherwise */
  483. - (int) murderEvent : (EFileLink) here
  484. {
  485.     Event *event;
  486.     
  487.     #ifdef DEBUG
  488.         fprintf(stderr,"Arrggh! Help! I'm getting murdered! "
  489.             "(says Event <%d>)\n\n",
  490.             here);
  491.     #endif
  492.     
  493.     event = [Event newAt :eventFile];
  494.     [event readEvent : here];        //    Read the event in
  495.     [event deleteEvent : here];        //    Delete the event
  496.     
  497.     if( (int) ([event anniversary]/100) == 0)        // No anniversary
  498.         return -1;
  499.         
  500.     [event setTime: fixAnniversary( [event time], [event anniversary], 
  501.         [event annvSpecial])];
  502.     //     Fix the next event time and reinsert it
  503.                                 
  504.     // Use the same EFilelink space that we deleted, this saves 
  505.     // us time and maybe some confusion 
  506.     return( [event insertEventFrom:here]  );
  507. }
  508.  
  509.  
  510. - (EFileLink) present
  511. {
  512.     return present;
  513. }
  514.  
  515. - (EFileLink) previous
  516. {
  517.     return previous;
  518. }
  519.  
  520. - (EFileLink) next
  521. {
  522.     return next;
  523. }
  524.  
  525. - setPresent : (EFileLink) apresent
  526. {
  527.     present = apresent;
  528.     return self;
  529. }
  530. - setPrevious  : (EFileLink) aprevious
  531. {
  532.     previous =aprevious;
  533.     return self;
  534. }
  535.  
  536. - setNext  : (EFileLink) anext
  537. {
  538.     next = anext;
  539.     return self;
  540. }
  541.  
  542. - (struct tm *) time
  543. {
  544.     return &ts;
  545. }
  546.  
  547. - setTime : (struct tm *) time
  548. {    
  549.     ts = *time;
  550.     return self;
  551. }
  552.  
  553. - setMday : (int) x
  554. {    
  555.     ts.tm_mday = x;
  556.     return self;
  557. }
  558.  
  559. - (int) mday;
  560. {
  561.     return( ts.tm_mday);
  562. }
  563.  
  564. - setMon: (int) x
  565. {
  566.     ts.tm_mon = x;
  567.     return self;
  568. }
  569.  
  570. - (int) mon
  571. {
  572.     return (ts.tm_mon);
  573. }
  574.  
  575. - setYear: (int) x
  576. {
  577.     ts.tm_year = x;
  578.     return self;
  579. }
  580.  
  581. - (int) year
  582. {
  583.     return (ts.tm_year);
  584. }
  585.  
  586. - setHour: (int) x
  587. {
  588.     ts.tm_hour = x;
  589.     return self;
  590. }
  591.  
  592. - (int) hour
  593. {
  594.     return (ts.tm_hour);
  595. }
  596.  
  597. - setMin: (int) x
  598. {
  599.     ts.tm_min = x;
  600.     return self;
  601. }
  602.  
  603. - (int) min
  604. {
  605.     return(ts.tm_min);
  606. }
  607.  
  608. - setSec: (int) x
  609. {
  610.     ts.tm_sec = x;
  611.     return self;
  612. }
  613.  
  614. - (int) sec
  615. {
  616.     return(ts.tm_sec);
  617. }
  618.  
  619. - (int) destroy
  620. {
  621.     return destroy;
  622. }
  623.  
  624. - setDestroy : (int) dst
  625. {
  626.     destroy = dst;
  627.     return self;
  628. }
  629.  
  630.  
  631. - (int) anniversary
  632. {
  633.     return anniversary;
  634. }
  635.  
  636. - setAnniversary : (int) anv
  637. {
  638.     anniversary = anv;
  639.     return self;
  640. }
  641.  
  642.  
  643. - (int) annvSpecial
  644. {
  645.     return annvSpecial;
  646. }
  647.  
  648. - setAnnvSpecial : (int) anvS
  649. {
  650.     annvSpecial = anvS;
  651.     return self;
  652. }
  653.  
  654. - (int) snoozeNo
  655. {
  656.     return snoozeNo;
  657. }
  658.  
  659. - setSnoozeNo : (int) sn
  660. {
  661.     snoozeNo = sn;
  662.     return self;
  663. }
  664.  
  665.  
  666. - (int) snoozeInt
  667. {
  668.     return snoozeInt;
  669. }
  670.  
  671. - setSnoozeInt : (int) si
  672. {
  673.     snoozeInt = si;
  674.     return self;
  675. }
  676.  
  677. - (int) priority
  678. {
  679.     return priority;
  680. }
  681.  
  682. - setPriority : (int) si
  683. {
  684.     priority = si;
  685.     return self;
  686. }
  687.  
  688. - (char *) alarmSound
  689. {
  690.     return alarmSound;
  691. }
  692.  
  693. - setAlarmSound : (char *) aS
  694. {    
  695.     strcpy( alarmSound, aS);
  696.     return self;
  697. }
  698.  
  699. - setPlayAlarm: (BOOL) aFlag
  700. {
  701.     playAlarm = aFlag;
  702.     return self;
  703. }
  704.  
  705.  
  706. - (BOOL) playAlarm
  707. {
  708.     return playAlarm;
  709. }
  710.  
  711. - setShowMessage: (BOOL) aFlag
  712. {
  713.     showMessage = aFlag;
  714.     return self;
  715. }
  716.  
  717.  
  718. - (BOOL) showMessage
  719. {
  720.     return showMessage;
  721. }
  722.  
  723.  
  724. - (char *) message
  725. {
  726.     return msg;
  727. }
  728.  
  729.  
  730. - (BOOL) deleteSound
  731. {
  732.     return deleteSound;
  733. }
  734.  
  735. - setDeleteSound: (BOOL) aFlag
  736. {
  737.     deleteSound = aFlag;
  738.     return self;
  739. }
  740.  
  741. - setMessage : (char *) message
  742. {    
  743.     strcpy( msg, message);
  744.     return self;
  745. }
  746.  
  747. - setWday : (int) wd
  748. {
  749.     ts.tm_wday = wd;
  750.     return self;
  751. }
  752.  
  753. - setYday : (int) yd
  754. {
  755.     ts.tm_yday = yd;
  756.     return self;
  757. }
  758.  
  759. - (int) wday
  760. {
  761.     return ts.tm_wday;
  762. }
  763.  
  764. - (int) yday
  765. {
  766.     return ts.tm_yday;
  767. }
  768. @end        
  769.  
  770.  
  771. struct tm *fixAnniversary( struct tm *time, int mode, int sub)
  772. {
  773.     #ifdef DEBUG
  774.     fprintf(stderr,"Fixing weekly special: %s, %d, %d\n", ascMyTime(time, YES, NO), 
  775.         mode, sub);
  776.     #endif
  777.  
  778.     switch( (int) mode  / 100)      
  779.         {
  780.         /* Don't worry about overflows as we add intervals to */
  781.         /* our dates, insertEvent is smart enough to handle it */
  782.         case 0:
  783.             return time;    /* No anniversary */
  784.         case 1:            /* If it is a day anniversary */
  785.             time->tm_mday+=  (mode - 100);
  786.             break;
  787.         case 2:            /* Weekly anniversary */
  788.             time -> tm_mday +=  ((mode - 200) * 7 );
  789.             break;
  790.         case 3:            /* Monthly anniversary */
  791.             time-> tm_mon += (mode - 300);
  792.             break;
  793.         case 4:            /* Yearly anniversary */
  794.             time -> tm_year +=  (mode - 400);
  795.             break;
  796.         case 5:            /* Special weekly */
  797.         default:
  798.              fprintf(stderr,
  799.                 "%s: I do not recognize anniversary event: %d.\n", 
  800.                 PROGNAME,
  801.                  mode);
  802.              return time;
  803.         }
  804.  
  805.     fixTmStructure( time);
  806.     return time;
  807. }
  808.  
  809.  
  810.